//package cn.nexd.task.core;
//
//import android.os.Handler;
//import android.os.Message;
//import android.os.Process;
//
//import java.util.ArrayDeque;
//import java.util.concurrent.BlockingDeque;
//import java.util.concurrent.Callable;
//import java.util.concurrent.CancellationException;
//import java.util.concurrent.ExecutionException;
//import java.util.concurrent.Executor;
//import java.util.concurrent.FutureTask;
//import java.util.concurrent.LinkedBlockingDeque;
//import java.util.concurrent.ThreadFactory;
//import java.util.concurrent.ThreadPoolExecutor;
//import java.util.concurrent.TimeUnit;
//import java.util.concurrent.atomic.AtomicBoolean;
//import java.util.concurrent.atomic.AtomicInteger;
//
///**
// * AsyncTask create by codingfish at 15/5/26
// * TODO:
// *
// * @Version V1.0
// */
//public abstract class AsyncTask<Params, Progress, Result> {
//
//    // log TAG
//    private static final String TAG = "NexdAsyncTask";
//
//    //当前设备的 CPU 核心数量
//    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//
//    //线程池核心线程容量
//    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
//
//    // 线程池最大线程容量
//    private static final int MAX_POOL_SIZE = CPU_COUNT * 2 + 1;
//
//    // 线程池空闲线程的存活时间
//    private static final int KEEP_ALIVE_TIME = 1;
//
//    // priThreadFactory 线程工厂，通过工厂方法newThread来获取新线程
//    private static final ThreadFactory threadFactory = new ThreadFactory() {
//        private final AtomicInteger mCount = new AtomicInteger(1);
//
//        @Override
//        public Thread newThread(Runnable r) {
//            return new Thread(r, TAG + mCount.getAndIncrement());
//        }
//    };
//
//    // 任务调度器
//    private static final Executor complicatingExecutor = new ComplicatingExecutor();
//    private static volatile Executor serialExecutor = new SerialExecutor();
//
//    private static InternalHandler internalHandler = null;
//
//    //静态阻塞式队列，用来存放待执行的任务，初始容量：128个
//    private static final BlockingDeque<Runnable> threadPoolWorkQueue = new LinkedBlockingDeque<Runnable>(128);
//
//    //静态并发线程池，可以用来并行执行任务
//    private static final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, threadPoolWorkQueue, threadFactory);
//
//
//    //Handler 消息类型：发送结果
//    private static final int MESSAGE_POST_RESULT = 0x1;
//    //Handler 消息类型：更新进度
//    private static final int MESSAGE_POST_PROGRESS = 0x2;
//    //Handler 消息类型：取消执行
//    private static final int MESSAGE_POST_CANCEL = 0x3;
//
//    //原子布尔型，支持高并发访问，标识任务是否被取消
//    private final AtomicBoolean cancelled = new AtomicBoolean();
//    //原子布尔型，支持高并发访问，标识任务是否被执行过
//    private final AtomicBoolean taskInvoked = new AtomicBoolean();
//
//
//    private static final int DEFAULT_PRIORITY = Process.THREAD_PRIORITY_BACKGROUND;
//    private WorkerRunnable<Params, Result> worker;
//    private FutureTask<Result> futureTask;
//
//    private NexdAsyncTask.Status status = NexdAsyncTask.Status.PENDING;
//
//    protected AsyncTask() {
//        worker = new WorkerRunnable<Params, Result>() {
//            @Override
//            public Result call() throws Exception {
//                taskInvoked.set(true);
//                Process.setThreadPriority(DEFAULT_PRIORITY);
//                return doInBackground(mParams);
//            }
//        };
//
//        futureTask = new FutureTask<Result>(worker) {
//            @Override
//            protected void done() {
//
//                super.done();
//                try {
//                    final Result result = get();
//                    postResult(result);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                } catch (ExecutionException e) {
//                    throw new RuntimeException("An error occured while executing doInBackground()",
//                            e.getCause());
//                } catch (CancellationException e) {
//                    postCancel(null);
//                }
//            }
//        };
//
//        internalHandler = new InternalHandler();
//    }
//
//    /*该方法会在后台任务开始执行之间调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等。*/
//    protected void onPreExecute() {
//
//    }
//
//    /*方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。
//    * 任务一旦完成就可以通过return语句来将任务的执行结果进行返回，如果AsyncTask的第三个泛型参数指定的是Void，就可以不返回任务执行结果。
//    * 注意，在这个方法中是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress...)方法来完成。*/
//    protected abstract Result doInBackground(Params... params);
//
//    /*当在后台任务中调用了publishProgress(Progress...)方法后，这个方法就很快会被调用，方法中携带的参数就是在后台任务中传递过来的。
//    * 在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。*/
//    protected void onProgressUpdate(Progress... values) {
//    }
//
//
//    /*当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。
//    * 返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进度条对话框等。*/
//    protected void onPostExecute(Result result) {
//
//    }
//
//
//    private Result postResult(Result result) {
//        final boolean wasTaskInvoked = taskInvoked.get();
//        if (wasTaskInvoked) {
//            internalHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result)).sendToTarget();
//        }
//        return result;
//    }
//
//    private void postCancel(Result result) {
//        final boolean wasTaskCancel = cancelled.get();
//        if (wasTaskCancel) {
//            internalHandler.obtainMessage(MESSAGE_POST_CANCEL, new AsyncTaskResult<Result>(this, result)).sendToTarget();
//        }
//    }
//
//    protected void onCancelled(Result result) {
//    }
//
//    public final boolean isCancelled() {
//        return cancelled.get();
//    }
//
//    private void finish(Result result, int type) {
//        switch (type) {
//            case MESSAGE_POST_RESULT:
//                onPostExecute(result);
//                break;
//            case MESSAGE_POST_CANCEL:
//                onCancelled(result);
//                break;
//        }
//        status = NexdAsyncTask.Status.FINISHED;
//    }
//
//    protected final void publishProgress(Progress... values) {
//        if (!isCancelled()) {
//            internalHandler.obtainMessage(MESSAGE_POST_PROGRESS, new AsyncTaskResult<Progress>(this, values)).sendToTarget();
//        }
//    }
//
//    private static class InternalHandler extends Handler {
//        @Override
//        public void handleMessage(Message msg) {
//            super.handleMessage(msg);
//            AsyncTaskResult taskResult = (AsyncTaskResult) msg.obj;
//            switch (msg.what) {
//                case MESSAGE_POST_RESULT:
//                    taskResult.mTask.finish(taskResult.mData[0], MESSAGE_POST_RESULT);
//                    break;
//                case MESSAGE_POST_PROGRESS:
//                    taskResult.mTask.onProgressUpdate(taskResult.mData);
//                    break;
//                case MESSAGE_POST_CANCEL:
//                    taskResult.mTask.finish(taskResult.mData[0], MESSAGE_POST_CANCEL);
//            }
//        }
//    }
//
//    public void execute(Runnable runnable) {
//        serialExecutor.execute(runnable);
//    }
//
//    public AsyncTask<Params, Progress, Result> execute(Executor executor, Params... params) {
//
//        if (status != NexdAsyncTask.Status.PENDING) {
//            switch (status) {
//                case RUNNING:
//                    throw new IllegalStateException("Cannot execute task:"
//                            + " the taskis already running.");
//                case FINISHED:
//                    throw new IllegalStateException("Cannot execute task:"
//                            + " the taskhas already been executed "
//                            + "(a task canbe executed only once)");
//            }
//        }
//        status = NexdAsyncTask.Status.RUNNING;
//
//        onPreExecute();
//        worker.mParams = params;
//        executor.execute(futureTask);
//
//        return this;
//    }
//
//    public AsyncTask<Params, Progress, Result> execute(Params... params) {
//        return execute(serialExecutor, params);
//    }
//
//    public boolean cancel(boolean mayInterruptIfRunning) {
//        cancelled.set(true);
//        return futureTask.cancel(mayInterruptIfRunning);
//    }
//
//    private static class ComplicatingExecutor implements Executor {
//
//        @Override
//        public void execute(Runnable command) {
//
//        }
//    }
//
//    private static class SerialExecutor implements Executor {
//        ArrayDeque<Runnable> taskQueue = new ArrayDeque<Runnable>();
//
//        Runnable mActive;
//
//        @Override
//        public void execute(final Runnable command) {
//            taskQueue.offer(new Runnable() {
//                @Override
//                public void run() {
//                    try {
//                        command.run();
//                    } finally {
//                        scheduleNext();
//                    }
//                }
//            });
//
//            if (mActive == null) {
//                scheduleNext();
//            }
//        }
//
//        protected synchronized void scheduleNext() {
//            if ((mActive = taskQueue.poll()) != null) {
//                threadPoolExecutor.execute(mActive);
//            }
//        }
//    }
//
//    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
//        Params[] mParams;
//    }
//
//
//    public enum TaskStatus {
//        /**
//         * 任务等待执行
//         */
//        PENDING,
//        /**
//         * 任务正在执行
//         */
//        RUNNING,
//        /**
//         * 任务已经执行结束
//         */
//        FINISHED
//    }
//
//    private static class AsyncTaskResult<Data> {
//        final AsyncTask mTask;
//        final Data[] mData;
//
//        AsyncTaskResult(AsyncTask task, Data... data) {
//            mTask = task;
//            mData = data;
//        }
//    }
//}
